+Wed Mar 28 20:30:26 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.[ch] (_gtk_widget_get_aux_info): Add private function
+ to get the aux info structure fo the widget.
+
+ * gtk/gtklabel.c gtk/gtkscrolledwindow.c gtk/gtkwindow.c: Use
+ above function.
+
+ [ Patch from Havoc Pennington <hp@redhat.com> ]
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_get_frame_extents): function
+ to get the size of the window manager frame, basically the same
+ code that gdk_window_get_root_origin() had
+ (gdk_window_get_root_origin): use gdk_window_get_frame_extents()
+
+ * gtk/gtkwindow.c (gtk_window_set_default_size): use
+ gdk_window_resize() if the window is realized and resizeable
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_set_geometry_hints): fix
+ typo so that setting gravity works
+
+ * gtk/gtkwindow.c (gtk_window_move_resize): don't ever use
+ allocation if auto_shrink is on, even if the default size
+ has not changed.
+
+ * gtk/gtkwidget.c (gtk_widget_render_icon): remove bogus
+ g_return_if_fail
+
Thu Mar 29 16:29:12 2001 Jonathan Blandford <jrb@webwynk.net>
* gtk/gtkliststore.c (gtk_list_store_iter_changed): Massive
+Wed Mar 28 20:30:26 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.[ch] (_gtk_widget_get_aux_info): Add private function
+ to get the aux info structure fo the widget.
+
+ * gtk/gtklabel.c gtk/gtkscrolledwindow.c gtk/gtkwindow.c: Use
+ above function.
+
+ [ Patch from Havoc Pennington <hp@redhat.com> ]
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_get_frame_extents): function
+ to get the size of the window manager frame, basically the same
+ code that gdk_window_get_root_origin() had
+ (gdk_window_get_root_origin): use gdk_window_get_frame_extents()
+
+ * gtk/gtkwindow.c (gtk_window_set_default_size): use
+ gdk_window_resize() if the window is realized and resizeable
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_set_geometry_hints): fix
+ typo so that setting gravity works
+
+ * gtk/gtkwindow.c (gtk_window_move_resize): don't ever use
+ allocation if auto_shrink is on, even if the default size
+ has not changed.
+
+ * gtk/gtkwidget.c (gtk_widget_render_icon): remove bogus
+ g_return_if_fail
+
Thu Mar 29 16:29:12 2001 Jonathan Blandford <jrb@webwynk.net>
* gtk/gtkliststore.c (gtk_list_store_iter_changed): Massive
+Wed Mar 28 20:30:26 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.[ch] (_gtk_widget_get_aux_info): Add private function
+ to get the aux info structure fo the widget.
+
+ * gtk/gtklabel.c gtk/gtkscrolledwindow.c gtk/gtkwindow.c: Use
+ above function.
+
+ [ Patch from Havoc Pennington <hp@redhat.com> ]
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_get_frame_extents): function
+ to get the size of the window manager frame, basically the same
+ code that gdk_window_get_root_origin() had
+ (gdk_window_get_root_origin): use gdk_window_get_frame_extents()
+
+ * gtk/gtkwindow.c (gtk_window_set_default_size): use
+ gdk_window_resize() if the window is realized and resizeable
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_set_geometry_hints): fix
+ typo so that setting gravity works
+
+ * gtk/gtkwindow.c (gtk_window_move_resize): don't ever use
+ allocation if auto_shrink is on, even if the default size
+ has not changed.
+
+ * gtk/gtkwidget.c (gtk_widget_render_icon): remove bogus
+ g_return_if_fail
+
Thu Mar 29 16:29:12 2001 Jonathan Blandford <jrb@webwynk.net>
* gtk/gtkliststore.c (gtk_list_store_iter_changed): Massive
+Wed Mar 28 20:30:26 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.[ch] (_gtk_widget_get_aux_info): Add private function
+ to get the aux info structure fo the widget.
+
+ * gtk/gtklabel.c gtk/gtkscrolledwindow.c gtk/gtkwindow.c: Use
+ above function.
+
+ [ Patch from Havoc Pennington <hp@redhat.com> ]
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_get_frame_extents): function
+ to get the size of the window manager frame, basically the same
+ code that gdk_window_get_root_origin() had
+ (gdk_window_get_root_origin): use gdk_window_get_frame_extents()
+
+ * gtk/gtkwindow.c (gtk_window_set_default_size): use
+ gdk_window_resize() if the window is realized and resizeable
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_set_geometry_hints): fix
+ typo so that setting gravity works
+
+ * gtk/gtkwindow.c (gtk_window_move_resize): don't ever use
+ allocation if auto_shrink is on, even if the default size
+ has not changed.
+
+ * gtk/gtkwidget.c (gtk_widget_render_icon): remove bogus
+ g_return_if_fail
+
Thu Mar 29 16:29:12 2001 Jonathan Blandford <jrb@webwynk.net>
* gtk/gtkliststore.c (gtk_list_store_iter_changed): Massive
+Wed Mar 28 20:30:26 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.[ch] (_gtk_widget_get_aux_info): Add private function
+ to get the aux info structure fo the widget.
+
+ * gtk/gtklabel.c gtk/gtkscrolledwindow.c gtk/gtkwindow.c: Use
+ above function.
+
+ [ Patch from Havoc Pennington <hp@redhat.com> ]
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_get_frame_extents): function
+ to get the size of the window manager frame, basically the same
+ code that gdk_window_get_root_origin() had
+ (gdk_window_get_root_origin): use gdk_window_get_frame_extents()
+
+ * gtk/gtkwindow.c (gtk_window_set_default_size): use
+ gdk_window_resize() if the window is realized and resizeable
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_set_geometry_hints): fix
+ typo so that setting gravity works
+
+ * gtk/gtkwindow.c (gtk_window_move_resize): don't ever use
+ allocation if auto_shrink is on, even if the default size
+ has not changed.
+
+ * gtk/gtkwidget.c (gtk_widget_render_icon): remove bogus
+ g_return_if_fail
+
Thu Mar 29 16:29:12 2001 Jonathan Blandford <jrb@webwynk.net>
* gtk/gtkliststore.c (gtk_list_store_iter_changed): Massive
+Wed Mar 28 20:30:26 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.[ch] (_gtk_widget_get_aux_info): Add private function
+ to get the aux info structure fo the widget.
+
+ * gtk/gtklabel.c gtk/gtkscrolledwindow.c gtk/gtkwindow.c: Use
+ above function.
+
+ [ Patch from Havoc Pennington <hp@redhat.com> ]
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_get_frame_extents): function
+ to get the size of the window manager frame, basically the same
+ code that gdk_window_get_root_origin() had
+ (gdk_window_get_root_origin): use gdk_window_get_frame_extents()
+
+ * gtk/gtkwindow.c (gtk_window_set_default_size): use
+ gdk_window_resize() if the window is realized and resizeable
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_set_geometry_hints): fix
+ typo so that setting gravity works
+
+ * gtk/gtkwindow.c (gtk_window_move_resize): don't ever use
+ allocation if auto_shrink is on, even if the default size
+ has not changed.
+
+ * gtk/gtkwidget.c (gtk_widget_render_icon): remove bogus
+ g_return_if_fail
+
Thu Mar 29 16:29:12 2001 Jonathan Blandford <jrb@webwynk.net>
* gtk/gtkliststore.c (gtk_list_store_iter_changed): Massive
+Wed Mar 28 20:30:26 2001 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwidget.[ch] (_gtk_widget_get_aux_info): Add private function
+ to get the aux info structure fo the widget.
+
+ * gtk/gtklabel.c gtk/gtkscrolledwindow.c gtk/gtkwindow.c: Use
+ above function.
+
+ [ Patch from Havoc Pennington <hp@redhat.com> ]
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_get_frame_extents): function
+ to get the size of the window manager frame, basically the same
+ code that gdk_window_get_root_origin() had
+ (gdk_window_get_root_origin): use gdk_window_get_frame_extents()
+
+ * gtk/gtkwindow.c (gtk_window_set_default_size): use
+ gdk_window_resize() if the window is realized and resizeable
+
+ * gdk/x11/gdkwindow-x11.c (gdk_window_set_geometry_hints): fix
+ typo so that setting gravity works
+
+ * gtk/gtkwindow.c (gtk_window_move_resize): don't ever use
+ allocation if auto_shrink is on, even if the default size
+ has not changed.
+
+ * gtk/gtkwidget.c (gtk_widget_render_icon): remove bogus
+ g_return_if_fail
+
Thu Mar 29 16:29:12 2001 Jonathan Blandford <jrb@webwynk.net>
* gtk/gtkliststore.c (gtk_list_store_iter_changed): Massive
@y:
@width:
@height:
+@x_set:
+@y_set:
<!-- ##### STRUCT GtkWidgetShapeInfo ##### -->
<para>
void gdk_window_get_root_origin (GdkWindow *window,
gint *x,
gint *y);
+void gdk_window_get_frame_extents (GdkWindow *window,
+ GdkRectangle *rect);
GdkWindow* gdk_window_get_pointer (GdkWindow *window,
gint *x,
gint *y,
}
}
+/**
+ * gdk_window_get_origin:
+ * @window: a #GdkWindow
+ * @x: return location for X coordinate
+ * @y: return location for Y coordinate
+ *
+ * Obtains the position of a window in root window coordinates.
+ * (Compare with gdk_window_get_position() and
+ * gdk_window_get_geometry() which return the position of a window
+ * relative to its parent window.)
+ *
+ * Return value: not meaningful, ignore
+ **/
gint
gdk_window_get_origin (GdkWindow *window,
gint *x,
return return_val;
}
+/**
+ * gdk_window_get_deskrelative_origin:
+ * @window: a #GdkWindow
+ * @x: return location for X coordinate
+ * @y: return location for Y coordinate
+ *
+ * This gets the origin of a #GdkWindow relative to
+ * an Enlightenment-window-manager desktop. As long as you don't
+ * assume that the user's desktop/workspace covers the entire
+ * root window (i.e. you don't assume that the desktop begins
+ * at root window coordinate 0,0) this function is not necessary.
+ * It's deprecated for that reason.
+ *
+ * Return value: not meaningful
+ **/
gboolean
gdk_window_get_deskrelative_origin (GdkWindow *window,
gint *x,
return return_val;
}
+/**
+ * gdk_window_get_root_origin:
+ * @window: a #GdkWindow
+ * @x: return location for X position of window frame
+ * @y: return location for Y position of window frame
+ *
+ * Obtains the top-left corner of the window manager frame in root
+ * window coordinates.
+ *
+ **/
void
gdk_window_get_root_origin (GdkWindow *window,
gint *x,
gint *y)
+{
+ GdkRectangle rect;
+
+ g_return_if_fail (GDK_IS_WINDOW (window));
+
+ gdk_window_get_frame_extents (window, &rect);
+
+ if (x)
+ *x = rect.x;
+
+ if (y)
+ *y = rect.y;
+}
+
+/**
+ * gdk_window_get_frame_extents:
+ * @window: a #GdkWindow
+ * @rect: rectangle to fill with bounding box of the window frame
+ *
+ * Obtains the bounding box of the window, including window manager
+ * titlebar/borders if any. The frame position is given in root window
+ * coordinates. To get the position of the window itself (rather than
+ * the frame) in root window coordinates, use gdk_window_get_origin().
+ *
+ **/
+void
+gdk_window_get_frame_extents (GdkWindow *window,
+ GdkRectangle *rect)
{
GdkWindowObject *private;
Window xwindow;
Window *children;
unsigned int nchildren;
- g_return_if_fail (window != NULL);
g_return_if_fail (GDK_IS_WINDOW (window));
+ g_return_if_fail (rect != NULL);
private = (GdkWindowObject*) window;
- if (x)
- *x = 0;
- if (y)
- *y = 0;
-
+
+ rect->x = 0;
+ rect->y = 0;
+ rect->width = 1;
+ rect->height = 1;
+
if (GDK_WINDOW_DESTROYED (window))
return;
if (XGetGeometry (GDK_WINDOW_XDISPLAY (window), xwindow, &root, &wx, &wy, &ww, &wh, &wb, &wd))
{
- if (x)
- *x = wx;
- if (y)
- *y = wy;
+ rect->x = wx;
+ rect->y = wy;
+ rect->width = ww;
+ rect->height = wh;
}
}
}
w += dx;
h += dy;
break;
-
}
w = MAX (w, 1);
gint width, height;
gint real_width;
- aux_info = gtk_object_get_data (GTK_OBJECT (widget), "gtk-aux-info");
+ aux_info = _gtk_widget_get_aux_info (widget, FALSE);
if (aux_info && aux_info->width > 0)
{
pango_layout_set_width (label->layout, aux_info->width * PANGO_SCALE);
if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
{
- static guint quark_aux_info = 0;
-
- if (!quark_aux_info)
- quark_aux_info = g_quark_from_static_string ("gtk-aux-info");
-
gtk_widget_size_request (bin->child, &child_requisition);
if (scrolled_window->hscrollbar_policy == GTK_POLICY_NEVER)
requisition->width += child_requisition.width;
else
{
- GtkWidgetAuxInfo *aux_info;
+ GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (bin->child, FALSE);
- aux_info = gtk_object_get_data_by_id (GTK_OBJECT (bin->child), quark_aux_info);
if (aux_info && aux_info->width > 0)
{
requisition->width += aux_info->width;
requisition->height += child_requisition.height;
else
{
- GtkWidgetAuxInfo *aux_info;
-
- aux_info = gtk_object_get_data_by_id (GTK_OBJECT (bin->child), quark_aux_info);
+ GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (bin->child, FALSE);
if (aux_info && aux_info->height > 0)
{
requisition->height += aux_info->height;
static GtkWidgetAuxInfo* gtk_widget_aux_info_new (void);
static void gtk_widget_aux_info_destroy (GtkWidgetAuxInfo *aux_info);
+static void gtk_widget_do_uposition (GtkWidget *widget);
+
static gpointer parent_class = NULL;
static guint widget_signals[LAST_SIGNAL] = { 0 };
guint arg_id)
{
GtkWidget *widget;
+ GtkWidgetAuxInfo *aux_info;
widget = GTK_WIDGET (object);
gtk_container_add (GTK_CONTAINER (GTK_VALUE_OBJECT (*arg)), widget);
break;
case ARG_X:
- gtk_widget_set_uposition (widget, GTK_VALUE_INT (*arg), -2);
+ aux_info = _gtk_widget_get_aux_info (widget, TRUE);
+ if (GTK_VALUE_INT (*arg) == -1)
+ aux_info->x_set = FALSE;
+ else
+ {
+ aux_info->x_set = TRUE;
+ aux_info->x = GTK_VALUE_INT (*arg);
+ }
+ gtk_widget_do_uposition (widget);
break;
case ARG_Y:
- gtk_widget_set_uposition (widget, -2, GTK_VALUE_INT (*arg));
+ aux_info = _gtk_widget_get_aux_info (widget, TRUE);
+ if (GTK_VALUE_INT (*arg) == -1)
+ aux_info->y_set = FALSE;
+ else
+ {
+ aux_info->y_set = TRUE;
+ aux_info->y = GTK_VALUE_INT (*arg);
+ }
+ gtk_widget_do_uposition (widget);
break;
case ARG_WIDTH:
gtk_widget_set_usize (widget, GTK_VALUE_INT (*arg), -2);
GTK_VALUE_OBJECT (*arg) = (GtkObject*) widget->parent;
break;
case ARG_X:
- aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
- if (!aux_info)
+ aux_info =_gtk_widget_get_aux_info (widget, FALSE);
+ if (!aux_info || !aux_info->x_set)
GTK_VALUE_INT (*arg) = -1;
else
GTK_VALUE_INT (*arg) = aux_info->x;
break;
case ARG_Y:
- aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
- if (!aux_info)
+ aux_info =_gtk_widget_get_aux_info (widget, FALSE);
+ if (!aux_info || !aux_info->y_set)
GTK_VALUE_INT (*arg) = -1;
else
GTK_VALUE_INT (*arg) = aux_info->y;
break;
case ARG_WIDTH:
- aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
+ aux_info =_gtk_widget_get_aux_info (widget, FALSE);
if (!aux_info)
GTK_VALUE_INT (*arg) = -1;
else
GTK_VALUE_INT (*arg) = aux_info->width;
break;
case ARG_HEIGHT:
- aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
+ aux_info =_gtk_widget_get_aux_info (widget, FALSE);
if (!aux_info)
GTK_VALUE_INT (*arg) = -1;
else
*requisition = widget->requisition;
- aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
+ aux_info =_gtk_widget_get_aux_info (widget, FALSE);
if (aux_info)
{
if (aux_info->width > 0)
g_return_if_fail (GTK_IS_WIDGET (widget));
real_allocation = *allocation;
- aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
+ aux_info =_gtk_widget_get_aux_info (widget, FALSE);
if (aux_info)
{
return (parent_window != NULL) ? parent_window : widget->parent->window;
}
+/* Update the position from aux_info. Used from gtk_widget_set_uposition
+ * and gtk_widget_set_arg().
+ */
+static void
+gtk_widget_do_uposition (GtkWidget *widget)
+{
+ GtkWidgetAuxInfo *aux_info =_gtk_widget_get_aux_info (widget, FALSE);
+
+ if (GTK_IS_WINDOW (widget) && aux_info->x_set && aux_info->y_set)
+ gtk_window_reposition (GTK_WINDOW (widget), aux_info->x, aux_info->y);
+
+ if (GTK_WIDGET_VISIBLE (widget) && widget->parent)
+ gtk_widget_size_allocate (widget, &widget->allocation);
+}
+
/**
* gtk_widget_set_uposition:
* @widget: a #GtkWidget
- * @x: x position
- * @y: y position
+ * @x: x position; -1 to unset x; -2 to leave x unchanged
+ * @y: y position; -1 to unset y; -2 to leave y unchanged
*
*
* Sets the position of a widget. The funny "u" in the name comes from
* window; most window managers will do the centering on your behalf
* if you call gtk_window_set_transient_for(), and it's really not
* possible to get the centering to work correctly in all cases from
- * application code.
+ * application code. But if you insist, use gtk_window_set_position()
+ * to set #GTK_WIN_POS_CENTER_ON_PARENT, don't do the centering
+ * manually.
+ *
+ * Note that although x and y can be individually unset, the position
+ * is not honoured unless both x and y are set.
**/
void
gtk_widget_set_uposition (GtkWidget *widget,
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
- aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
- if (!aux_info)
- {
- aux_info = gtk_widget_aux_info_new ();
- gtk_object_set_data_by_id (GTK_OBJECT (widget), quark_aux_info, aux_info);
- }
+ aux_info =_gtk_widget_get_aux_info (widget, TRUE);
- /* keep this in sync with gtk_window_compute_reposition() */
+ /* keep this in sync with gtk_window_set_location() */
if (x > -2)
- aux_info->x = x;
+ {
+ if (x == -1)
+ aux_info->x_set = FALSE;
+ else
+ {
+ aux_info->x_set = TRUE;
+ aux_info->x = x;
+ }
+ }
+
if (y > -2)
- aux_info->y = y;
-
- if (GTK_IS_WINDOW (widget) && (aux_info->x != -1) && (aux_info->y != -1))
- gtk_window_reposition (GTK_WINDOW (widget), x, y);
-
- if (GTK_WIDGET_VISIBLE (widget) && widget->parent)
- gtk_widget_size_allocate (widget, &widget->allocation);
+ {
+ if (y == -1)
+ aux_info->y_set = FALSE;
+ else
+ {
+ aux_info->y_set = TRUE;
+ aux_info->y = y;
+ }
+ }
+
+ gtk_widget_do_uposition (widget);
}
/**
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
- aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
- if (!aux_info)
- {
- aux_info = gtk_widget_aux_info_new ();
- gtk_object_set_data_by_id (GTK_OBJECT (widget), quark_aux_info, aux_info);
- }
+ aux_info =_gtk_widget_get_aux_info (widget, TRUE);
if (width > -2)
aux_info->width = width;
if (widget->name)
g_free (widget->name);
- aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
+ aux_info =_gtk_widget_get_aux_info (widget, FALSE);
if (aux_info)
gtk_widget_aux_info_destroy (aux_info);
}
}
+/**
+ * _gtk_widget_get_aux_info:
+ * @widget: a #GtkWidget
+ * @create: if %TRUE, create the structure if it doesn't exist
+ *
+ * Get the #GtkWidgetAuxInfo structure for the widget.
+ *
+ * Return value: the #GtkAuxInfo structure for the widget, or
+ * %NULL if @create is %FALSE and one doesn't already exist.
+ **/
+GtkWidgetAuxInfo *
+_gtk_widget_get_aux_info (GtkWidget *widget,
+ gboolean create)
+{
+ GtkWidgetAuxInfo *aux_info;
+
+ aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), quark_aux_info);
+ if (!aux_info && create)
+ {
+ aux_info = gtk_widget_aux_info_new ();
+ gtk_object_set_data_by_id (GTK_OBJECT (widget), quark_aux_info, aux_info);
+
+ aux_info->width = aux_info->height = -1;
+ aux_info->x = aux_info->y = 0;
+ aux_info->x_set = aux_info->y_set = FALSE;
+ }
+
+ return aux_info;
+}
+
/*****************************************
* gtk_widget_aux_info_new:
*
gint y;
gint width;
gint height;
+ guint x_set : 1;
+ guint y_set : 1;
};
struct _GtkWidgetShapeInfo
# define gtk_widget_unref gtk_object_unref
#endif /* GTK_TRACE_OBJECTS && __GNUC__ */
+GtkWidgetAuxInfo *_gtk_widget_get_aux_info (GtkWidget *widget,
+ gboolean create);
#ifdef __cplusplus
}
PROP_DEFAULT_WIDTH,
PROP_DEFAULT_HEIGHT,
PROP_DESTROY_WITH_PARENT,
-
+
LAST_ARG
};
GdkGeometry geometry; /* Geometry hints */
GdkWindowHints mask;
GtkWidget *widget; /* subwidget to which hints apply */
- gint width; /* Default size */
+ gint width; /* gtk_window_set_default_size () */
gint height;
GtkWindowLastGeometryInfo last;
static void gtk_window_compute_hints (GtkWindow *window,
GdkGeometry *new_geometry,
guint *new_flags);
-static void gtk_window_compute_reposition (GtkWindow *window,
- gint new_width,
- gint new_height,
- gint *x,
- gint *y);
+static gboolean gtk_window_compute_reposition (GtkWindow *window,
+ gint new_width,
+ gint new_height,
+ gint *x,
+ gint *y);
static void gtk_window_read_rcfiles (GtkWidget *widget,
GdkEventClient *event);
window->frame_top = 0;
window->frame_bottom = 0;
window->type_hint = GDK_WINDOW_TYPE_HINT_NORMAL;
+ window->gravity = GDK_GRAVITY_NORTH_WEST;
window->decorated = TRUE;
window->mnemonic_modifier = GDK_MOD1_MASK;
g_object_notify (G_OBJECT (window), "width");
if (height >= 0)
g_object_notify (G_OBJECT (window), "height");
-
- gtk_widget_queue_resize (GTK_WIDGET (window));
+
+ if (GTK_WIDGET_REALIZED (window) && window->allow_grow)
+ {
+ /* Resize as if the user had resized */
+ GdkGeometry new_geometry;
+ GdkWindowHints new_flags;
+
+ gtk_window_compute_hints (window, &new_geometry, &new_flags);
+ gtk_window_constrain_size (window,
+ &new_geometry, new_flags,
+ width, height,
+ &width, &height);
+
+ gdk_window_resize (GTK_WIDGET (window)->window,
+ width, height);
+ }
+ else
+ gtk_widget_queue_resize (GTK_WIDGET (window));
}
static void
GtkWindowLastGeometryInfo saved_last_info;
GdkGeometry new_geometry;
guint new_flags;
+ gboolean need_reposition;
gint x, y;
gint width, height;
gint new_width, new_height;
/* From the default size and the allocation, figure out the size
* the window should be.
*/
- if (!default_size_changed ||
- (!window->auto_shrink &&
- new_width <= widget->allocation.width &&
- new_height <= widget->allocation.height))
+ if (!window->auto_shrink &&
+ (!default_size_changed ||
+ (new_width <= widget->allocation.width &&
+ new_height <= widget->allocation.height)))
{
new_width = widget->allocation.width;
new_height = widget->allocation.height;
/* compute new window position if a move is required
*/
- gtk_window_compute_reposition (window, new_width, new_height, &x, &y);
- if (x != 1 && y != -1 && !(new_flags & GDK_HINT_POS))
+ need_reposition = gtk_window_compute_reposition (window, new_width, new_height, &x, &y);
+ if (need_reposition && !(new_flags & GDK_HINT_POS))
{
new_flags |= GDK_HINT_POS;
hints_changed = TRUE;
* the new size had been set.
*/
- if (x != -1 && y != -1)
+ if (need_reposition)
{
if (window->frame)
gdk_window_move (window->frame, x - window->frame_left, y - window->frame_top);
*/
/* request a new window size */
- if (x != -1 && y != -1)
+ if (need_reposition)
{
if (window->frame)
{
}
else
{
- if (x != -1 && y != -1)
+ if (need_reposition)
{
if (window->frame)
gdk_window_move (window->frame, x - window->frame_left, y - window->frame_top);
geometry_a->height_inc != geometry_b->height_inc))
return FALSE;
+ if ((flags_a & GDK_HINT_WIN_GRAVITY) &&
+ (geometry_a->win_gravity != geometry_b->win_gravity))
+ return FALSE;
+
return TRUE;
}
ux = 0;
uy = 0;
- aux_info = gtk_object_get_data (GTK_OBJECT (widget), "gtk-aux-info");
- if (aux_info && (aux_info->x != -1) && (aux_info->y != -1))
+ aux_info = _gtk_widget_get_aux_info (widget, FALSE);
+ if (aux_info && aux_info->x_set && aux_info->y_set)
{
ux = aux_info->x;
uy = aux_info->y;
new_geometry->max_width = requisition.width;
new_geometry->max_height = requisition.height;
}
+
+ *new_flags |= GDK_HINT_WIN_GRAVITY;
+ new_geometry->win_gravity = window->gravity;
}
/* Compute a new position for the window based on a new
- * size. *x and *y will be set to the new coordinates, or to -1 if the
- * window does not need to be moved
+ * size. *x and *y will be set to the new coordinates. Returns
+ * TRUE if the window needs to be moved;
*/
-static void
+static gboolean
gtk_window_compute_reposition (GtkWindow *window,
gint new_width,
gint new_height,
GtkWidget *widget;
GtkWindowPosition pos;
GtkWidget *parent_widget;
+ gboolean result = FALSE;
widget = GTK_WIDGET (window);
- *x = -1;
- *y = -1;
-
parent_widget = (GtkWidget*) window->transient_parent;
pos = window->position;
*x = (screen_width - new_width) / 2;
*y = (screen_height - new_height) / 2;
+
+ result = TRUE;
}
break;
*x = ox + (parent_widget->allocation.width - new_width) / 2;
*y = oy + (parent_widget->allocation.height - new_height) / 2;
+
+ result = TRUE;
}
break;
*y -= new_height / 2;
*x = CLAMP (*x, 0, screen_width - new_width);
*y = CLAMP (*y, 0, screen_height - new_height);
+
+ result = TRUE;
}
break;
default:
if (window->use_uposition)
{
- GtkWidgetAuxInfo *aux_info;
-
- aux_info = gtk_object_get_data (GTK_OBJECT (window), "gtk-aux-info");
- if (aux_info &&
- aux_info->x != -1 && aux_info->y != -1 &&
- aux_info->x != -2 && aux_info->y != -2)
+ GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (widget, FALSE);
+ if (aux_info && aux_info->x_set && aux_info->y_set)
{
*x = aux_info->x;
*y = aux_info->y;
}
+
+ result = TRUE;
}
break;
}
- if (*x != -1 && *y != -1)
+ if (result)
{
- GtkWidgetAuxInfo *aux_info;
+ GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (widget, TRUE);
- /* we handle necessary window positioning by hand here,
- * so we can coalesce the window movement with possible
- * resizes to get only one configure event.
- * keep this in sync with gtk_widget_set_uposition()
- * and gtk_window_reposition().
- */
- gtk_widget_set_uposition (widget, -1, -1); /* ensure we have aux_info */
-
- aux_info = gtk_object_get_data (GTK_OBJECT (widget), "gtk-aux-info");
+ aux_info->x_set = aux_info->y_set = TRUE;
aux_info->x = *x;
aux_info->y = *y;
window->use_uposition = FALSE;
}
+
+ return result;
}
/***********************
gdk_window_unmaximize (toplevel);
}
+/**
+ * gtk_window_set_resizeable:
+ * @window: a #GtkWindow
+ * @setting: %TRUE if the user can resize this window
+ *
+ * Sets whether the user can resize a window. Windows are user resizeable
+ * by default.
+ *
+ **/
+void
+gtk_window_set_resizeable (GtkWindow *window,
+ gboolean setting)
+{
+ g_return_if_fail (GTK_IS_WINDOW (window));
+
+ if (setting)
+ gtk_window_set_policy (window, FALSE, TRUE, FALSE);
+ else
+ gtk_window_set_policy (window, FALSE, FALSE, TRUE);
+}
+
+/**
+ * gtk_window_get_resizeable:
+ * @window: a #GtkWindow
+ *
+ * Gets the value set by gtk_window_set_resizeable().
+ *
+ * Return value: %TRUE if the user can resize the window
+ **/
+gboolean
+gtk_window_get_resizeable (GtkWindow *window)
+{
+ g_return_val_if_fail (GTK_IS_WINDOW (window), FALSE);
+
+ /* allow_grow is most likely to indicate the semantic concept we
+ * mean by "resizeable" (and will be a reliable indicator if
+ * set_policy() hasn't been called)
+ */
+ return window->allow_grow;
+}
+
+
+/**
+ * gtk_window_set_size:
+ * @window: a #GtkWindow
+ * @width: width, or -1 to use the default width
+ * @height: height, or -1 to use the default height
+ *
+ * Sets the size of @window, but only works for resizeable windows
+ * (see gtk_window_set_resizeable()). Setting the size emulates a user
+ * resize operation. Therefore, setting the size less than the minimum
+ * size for the window will simply make the window its minimum size,
+ * and the user will be able to change the size that's set.
+ *
+ * This call also sets the default size of the window, so replaces
+ * gtk_window_set_default_size().
+ *
+ * To set a minimum size, or to set the size of a non-resizeable window,
+ * use gtk_widget_set_usize() on the window. Though normally it makes
+ * more sense to instead call gtk_widget_set_usize() on a child widget inside
+ * the window, rather than the window itself.
+ *
+ * Under the X Window System, window managers are allowed to ignore GTK+'s
+ * request to change a window's size. So your program should not rely on
+ * getting a specific size. (And, as noted in gtk_window_get_size(),
+ * a program that crucially relies on a specific size will generally have
+ * race conditions and be buggy anyway - rather than assuming a
+ * call to gtk_window_set_size() has taken effect, you should react
+ * to configure_event signals on your #GtkWindow.)
+ *
+ * If you set a geometry widget for the window with
+ * gtk_window_set_geometry_hints(), the size applies to the geometry
+ * widget, not the window itself.
+ *
+ * If you've called the deprecated gtk_window_set_policy() function,
+ * gtk_window_set_size() may not behave as expected, due to interaction
+ * with window policies.
+ **/
+void
+gtk_window_set_size (GtkWindow *window,
+ gint width,
+ gint height)
+{
+ g_return_if_fail (GTK_IS_WINDOW (window));
+ g_return_if_fail (width != 0);
+ g_return_if_fail (height != 0);
+
+ /* set_default_size() uses "0" to mean "unset", but we allow "-1"
+ * for that in this newer function
+ */
+ if (width < 0)
+ width = 0;
+ if (height < 0)
+ height = 0;
+
+ gtk_window_set_default_size (window, width, height);
+}
+
+/**
+ * gtk_window_get_size:
+ * @window: a #GtkWindow
+ * @width: return location for current width, or %NULL
+ * @height: return location for current height, or %NULL
+ *
+ * Obtains the current size of @window. If the window is not onscreen
+ * (i.e. has not been received its first configure_event after being
+ * shown with gtk_widget_show()), the size will be the size GTK+ will
+ * request for this window when it's shown. The window manager may
+ * not choose to give the window exactly this requested size.
+ *
+ * In general, code which depends on window size should connect to the
+ * configure_event on the window so that it can respond to changes in
+ * size caused by the user or by the window manager, in addition to
+ * changes in size created by your program.
+ *
+ * If you set a geometry widget for the window with
+ * gtk_window_set_geometry_hints(), the size retrieved is the size of
+ * the geometry widget, not the window itself.
+ *
+ **/
+void
+gtk_window_get_size (GtkWindow *window,
+ gint *width,
+ gint *height)
+{
+ GtkWindowGeometryInfo *info;
+ GtkWidget *widget = GTK_WIDGET (window);
+
+ g_return_if_fail (GTK_IS_WINDOW (window));
+
+ if (GTK_WIDGET_REALIZED (window))
+ {
+ gdk_window_get_size (GTK_WIDGET (window)->window,
+ width, height);
+ }
+ else
+ {
+ GdkGeometry new_geometry;
+ GdkWindowHints new_flags;
+ gint w, h;
+
+ gtk_widget_size_request (widget, NULL);
+ gtk_window_compute_default_size (window, &w, &h);
+
+ gtk_window_compute_hints (window, &new_geometry, &new_flags);
+ gtk_window_constrain_size (window,
+ &new_geometry, new_flags,
+ w, h,
+ &w, &h);
+
+ if (width)
+ *width = w;
+ if (height)
+ *height = h;
+ }
+
+ info = gtk_window_get_geometry_info (window, TRUE);
+ if (info->widget)
+ {
+ gint extra_width = widget->requisition.width - info->widget->requisition.width;
+ gint extra_height = widget->requisition.height - info->widget->requisition.height;
+
+ if (width)
+ *width -= extra_width;
+ if (height)
+ *height -= extra_height;
+ }
+}
+
+/**
+ * gtk_window_set_location:
+ * @window: a #GtkWindow
+ * @root_x: X position of gravity-determined reference point in root window coordinates
+ * @root_y: Y position of gravity-determined reference point in root window coordinates
+ *
+ * Requests a new position for a #GtkWindow. The position is given in
+ * root window coordinates, and is the position of the window's
+ * "reference point" as determined by the window gravity (see
+ * gtk_window_set_gravity()). By default, the reference point is the
+ * northwest (top left) corner of the window's titlebar. So if you
+ * set the window position to (0,0), the window's titlebar will end up
+ * in the top left corner of the root window. Note that the root
+ * window does not always correspond to the user's desktop area, so
+ * you may want to call gdk_workspace_get_extents() or
+ * gdk_desktop_get_extents() to decide where to place a window. The
+ * extents of the root window can be obtained using gdk_screen_width()
+ * and gdk_screen_height().
+ *
+ **/
+void
+gtk_window_set_location (GtkWindow *window,
+ gint root_x,
+ gint root_y)
+{
+ GtkWidgetAuxInfo *aux_info;
+
+ g_return_if_fail (GTK_IS_WINDOW (window));
+
+ aux_info = _gtk_widget_get_aux_info (GTK_WIDGET (window), TRUE);
+
+ aux_info->x_set = aux_info->y_set = TRUE;
+ aux_info->x = root_x;
+ aux_info->y = root_y;
+
+ gtk_window_reposition (window, root_x, root_y);
+}
+
+/**
+ * gtk_window_get_location:
+ * @window: a #GtkWindow
+ * @root_x: return location for X coordinate of gravity-determined reference point
+ * @root_y: return location for Y coordinate of gravity-determined reference point
+ *
+ * Attempts to obtain the current position of the reference point, as
+ * set by gtk_window_set_position(). This computation is accurate when
+ * the reference point is a corner of the window itself (as with
+ * #GDK_GRAVITY_STATIC), but may not be accurate when the reference
+ * point is a position on the titlebar or window border, because the X
+ * Window System does not provide a reliable way of obtaining this
+ * information. GTK+ will do a "best guess" which may not be fully
+ * accurate with some window managers, but will probably be
+ * reasonable.
+ *
+ **/
+void
+gtk_window_get_location (GtkWindow *window,
+ gint *root_x,
+ gint *root_y)
+{
+ GdkRectangle frame_extents;
+ GtkWidget *widget;
+ GtkWidgetAuxInfo *aux_info;
+
+ g_return_if_fail (GTK_IS_WINDOW (window));
+
+ widget = GTK_WIDGET (window);
+
+ if (GTK_WIDGET_REALIZED (window))
+ {
+ if (window->gravity == GDK_GRAVITY_STATIC)
+ {
+ gdk_window_get_origin (widget->window, root_x, root_y);
+ return;
+ }
+ else
+ {
+ gint x, y;
+
+ gdk_window_get_frame_extents (widget->window, &frame_extents);
+
+ x = frame_extents.x;
+ y = frame_extents.y;
+
+ switch (window->gravity)
+ {
+ case GDK_GRAVITY_NORTH:
+ case GDK_GRAVITY_CENTER:
+ case GDK_GRAVITY_SOUTH:
+ x += frame_extents.width / 2;
+ break;
+ case GDK_GRAVITY_SOUTH_EAST:
+ case GDK_GRAVITY_EAST:
+ case GDK_GRAVITY_NORTH_EAST:
+ x += frame_extents.width;
+ break;
+ default:
+ break;
+ }
+
+ switch (window->gravity)
+ {
+ case GDK_GRAVITY_WEST:
+ case GDK_GRAVITY_CENTER:
+ case GDK_GRAVITY_EAST:
+ y += frame_extents.height / 2;
+ break;
+ case GDK_GRAVITY_SOUTH_WEST:
+ case GDK_GRAVITY_SOUTH:
+ case GDK_GRAVITY_SOUTH_EAST:
+ y += frame_extents.height;
+ break;
+ default:
+ break;
+ }
+
+ if (root_x)
+ *root_x = x;
+ if (root_y)
+ *root_y = y;
+ }
+ }
+ else
+ {
+ /* We really don't have a location yet, so we make up some stuff,
+ * using the uposition if it's been set.
+ */
+ if (root_x)
+ *root_x = 0;
+
+ if (root_y)
+ *root_y = 0;
+
+ aux_info = _gtk_widget_get_aux_info (widget, FALSE);
+ if (aux_info && aux_info->x_set && aux_info->y_set)
+ {
+ *root_x = aux_info->x;
+ *root_y = aux_info->y;
+ }
+ }
+}
+
+/**
+ * gtk_window_set_gravity:
+ * @window: a #GtkWindow
+ * @gravity: window gravity
+ *
+ * Window gravity defines the "reference point" to be used when
+ * positioning or resizing a window. Calls to
+ * gtk_window_set_position() will position a different point on the
+ * window depending on the window gravity. When the window changes size
+ * the reference point determined by the window's gravity will stay in
+ * a fixed location.
+ *
+ * See #GdkGravity for full details. To briefly summarize,
+ * #GDK_GRAVITY_NORTH_WEST means that the reference point is the
+ * northwest (top left) corner of the window
+ * frame. #GDK_GRAVITY_SOUTH_EAST would be the bottom right corner of
+ * the frame, and so on. If you want to position the window contents,
+ * rather than the window manager's frame, #GDK_GRAVITY_STATIC moves
+ * the reference point to the northwest corner of the #GtkWindow
+ * itself.
+ *
+ * The default window gravity is #GDK_GRAVITY_NORTH_WEST.
+ *
+ **/
+void
+gtk_window_set_gravity (GtkWindow *window,
+ GdkGravity gravity)
+{
+ g_return_if_fail (GTK_IS_WINDOW (window));
+
+ if (gravity != window->gravity)
+ {
+ window->gravity = gravity;
+
+ /* This is sort of odd, but it keeps the hints recomputation
+ * in one place. Otherwise we're likely to mess up the
+ * recording of the last hints, etc.
+ */
+ gtk_widget_queue_resize (GTK_WIDGET (window));
+ }
+}
+
+/**
+ * gtk_window_get_gravity:
+ * @window: a #GtkWindow
+ *
+ * Gets the value set by gtk_window_set_gravity().
+ *
+ * Return value: window gravity
+ **/
+GdkGravity
+gtk_window_get_gravity (GtkWindow *window)
+{
+ g_return_val_if_fail (GTK_IS_WINDOW (window), 0);
+
+ return window->gravity;
+}
+
/**
* gtk_window_begin_resize_drag:
* @window: a #GtkWindow
timestamp);
}
-
/**
* gtk_window_begin_move_drag:
* @button: mouse button that initiated the drag
guint decorated : 1;
- GdkWindowTypeHint type_hint : 2;
+ GdkWindowTypeHint type_hint : 3;
+
+ GdkGravity gravity : 5;
guint frame_left;
guint frame_top;
const gchar *wmclass_class);
void gtk_window_set_role (GtkWindow *window,
const gchar *role);
-void gtk_window_set_policy (GtkWindow *window,
- gboolean allow_shrink,
- gboolean allow_grow,
- gboolean auto_shrink);
void gtk_window_add_accel_group (GtkWindow *window,
GtkAccelGroup *accel_group);
void gtk_window_remove_accel_group (GtkWindow *window,
GdkWindowTypeHint hint);
void gtk_window_set_destroy_with_parent (GtkWindow *window,
gboolean setting);
-void gtk_window_set_geometry_hints (GtkWindow *window,
- GtkWidget *geometry_widget,
- GdkGeometry *geometry,
- GdkWindowHints geom_mask);
void gtk_window_set_decorations_hint (GtkWindow *window,
GdkWMDecoration decorations);
void gtk_window_set_functions_hint (GtkWindow *window,
GdkWMFunction functions);
-/* The following differs from gtk_widget_set_usize, in that
- * gtk_widget_set_usize() overrides the requisition, so sets a minimum
- * size, while this only sets the size requested from the WM.
- */
-void gtk_window_set_default_size (GtkWindow *window,
- gint width,
- gint height);
+
+void gtk_window_set_resizeable (GtkWindow *window,
+ gboolean setting);
+gboolean gtk_window_get_resizeable (GtkWindow *window);
+
+
+void gtk_window_set_size (GtkWindow *window,
+ gint width,
+ gint height);
+void gtk_window_get_size (GtkWindow *window,
+ gint *width,
+ gint *height);
+
+void gtk_window_set_location (GtkWindow *window,
+ gint root_x,
+ gint root_y);
+void gtk_window_get_location (GtkWindow *window,
+ gint *root_x,
+ gint *root_y);
+
+void gtk_window_set_gravity (GtkWindow *window,
+ GdkGravity gravity);
+GdkGravity gtk_window_get_gravity (GtkWindow *window);
+
+
+void gtk_window_set_geometry_hints (GtkWindow *window,
+ GtkWidget *geometry_widget,
+ GdkGeometry *geometry,
+ GdkWindowHints geom_mask);
+
/* gtk_window_set_has_frame () must be called before realizing the window_*/
void gtk_window_set_has_frame (GtkWindow *window);
void gtk_window_set_frame_dimensions (GtkWindow *window,
void gtk_window_set_mnemonic_modifier (GtkWindow *window,
GdkModifierType modifier);
-
void gtk_window_present (GtkWindow *window);
void gtk_window_iconify (GtkWindow *window);
void gtk_window_deiconify (GtkWindow *window);
gint root_y,
guint32 timestamp);
+#ifndef GTK_DISABLE_DEPRECATED
+void gtk_window_set_policy (GtkWindow *window,
+ gint allow_shrink,
+ gint allow_grow,
+ gint auto_shrink);
+/* The following differs from gtk_widget_set_usize, in that
+ * gtk_widget_set_usize() overrides the requisition, so sets a minimum
+ * size, while this only sets the size requested from the WM.
+ */
+void gtk_window_set_default_size (GtkWindow *window,
+ gint width,
+ gint height);
+#endif
/* --- internal functions --- */
void gtk_window_set_focus (GtkWindow *window,
gtk_widget_destroy (window);
}
+/*
+ * Window sizing
+ */
+
+static gint
+configure_event_callback (GtkWidget *widget,
+ GdkEventConfigure *event,
+ gpointer data)
+{
+ GtkWidget *label = data;
+ gchar *msg;
+ gint x, y;
+
+ gtk_window_get_location (GTK_WINDOW (widget), &x, &y);
+
+ msg = g_strdup_printf ("event: %d,%d %d x %d\n"
+ "location: %d, %d",
+ event->x, event->y, event->width, event->height,
+ x, y);
+
+ gtk_label_set_text (GTK_LABEL (label), msg);
+
+ g_free (msg);
+
+ return FALSE;
+}
+
+static void
+get_ints (GtkWidget *window,
+ gint *a,
+ gint *b)
+{
+ GtkWidget *spin1;
+ GtkWidget *spin2;
+
+ spin1 = g_object_get_data (G_OBJECT (window), "spin1");
+ spin2 = g_object_get_data (G_OBJECT (window), "spin2");
+
+ *a = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
+ *b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
+}
+
+static void
+set_size_callback (GtkWidget *widget,
+ gpointer data)
+{
+ gint w, h;
+
+ get_ints (data, &w, &h);
+
+ gtk_window_set_size (g_object_get_data (data, "target"),
+ w, h);
+}
+
+static void
+set_default_size_callback (GtkWidget *widget,
+ gpointer data)
+{
+ gint w, h;
+
+ get_ints (data, &w, &h);
+
+ gtk_window_set_default_size (g_object_get_data (data, "target"),
+ w, h);
+}
+
+static void
+set_usize_callback (GtkWidget *widget,
+ gpointer data)
+{
+ gint w, h;
+
+ get_ints (data, &w, &h);
+
+ gtk_widget_set_usize (g_object_get_data (data, "target"),
+ w, h);
+}
+
+static void
+set_location_callback (GtkWidget *widget,
+ gpointer data)
+{
+ gint x, y;
+
+ get_ints (data, &x, &y);
+
+ gtk_window_set_location (g_object_get_data (data, "target"),
+ x, y);
+}
+
+static void
+allow_shrink_callback (GtkWidget *widget,
+ gpointer data)
+{
+ g_object_set (G_OBJECT (g_object_get_data (data, "target")),
+ "allow_shrink",
+ GTK_TOGGLE_BUTTON (widget)->active,
+ NULL);
+}
+
+static void
+allow_grow_callback (GtkWidget *widget,
+ gpointer data)
+{
+ g_object_set (G_OBJECT (g_object_get_data (data, "target")),
+ "allow_grow",
+ GTK_TOGGLE_BUTTON (widget)->active,
+ NULL);
+}
+
+static void
+auto_shrink_callback (GtkWidget *widget,
+ gpointer data)
+{
+ g_object_set (G_OBJECT (g_object_get_data (data, "target")),
+ "auto_shrink",
+ GTK_TOGGLE_BUTTON (widget)->active,
+ NULL);
+}
+
+static void
+gravity_selected (GtkWidget *widget,
+ gpointer data)
+{
+ gtk_window_set_gravity (G_OBJECT (g_object_get_data (data, "target")),
+ gtk_option_menu_get_history (GTK_OPTION_MENU (widget)) + GDK_GRAVITY_NORTH_WEST);
+}
+
+static GtkWidget*
+window_controls (GtkWidget *window)
+{
+ GtkWidget *control_window;
+ GtkWidget *label;
+ GtkWidget *vbox;
+ GtkWidget *button;
+ GtkWidget *spin;
+ GtkAdjustment *adj;
+ GtkWidget *om;
+ GtkWidget *menu;
+ gint i;
+
+ control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_title (GTK_WINDOW (control_window), "Size controls");
+
+ g_object_set_data (G_OBJECT (control_window),
+ "target",
+ window);
+
+ gtk_signal_connect_object (GTK_OBJECT (control_window),
+ "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ GTK_OBJECT (window));
+
+ vbox = gtk_vbox_new (FALSE, 5);
+
+ gtk_container_add (GTK_CONTAINER (control_window), vbox);
+
+ label = gtk_label_new ("<no configure events>");
+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+ gtk_signal_connect (GTK_OBJECT (window),
+ "configure_event",
+ GTK_SIGNAL_FUNC (configure_event_callback),
+ label);
+
+ adj = (GtkAdjustment *) gtk_adjustment_new (10.0, -3.0, 800.0, 1.0,
+ 5.0, 0.0);
+ spin = gtk_spin_button_new (adj, 0, 0);
+
+ gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
+
+ g_object_set_data (G_OBJECT (control_window), "spin1", spin);
+
+ adj = (GtkAdjustment *) gtk_adjustment_new (10.0, -3.0, 800.0, 1.0,
+ 5.0, 0.0);
+ spin = gtk_spin_button_new (adj, 0, 0);
+
+ gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
+
+ g_object_set_data (G_OBJECT (control_window), "spin2", spin);
+
+ button = gtk_button_new_with_label ("Queue resize");
+ gtk_signal_connect_object (GTK_WIDGET (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (gtk_widget_queue_resize),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Set size");
+ gtk_signal_connect (GTK_WIDGET (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (set_size_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Set default size");
+ gtk_signal_connect (GTK_WIDGET (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (set_default_size_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Set usize");
+ gtk_signal_connect (GTK_WIDGET (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (set_usize_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Set location");
+ gtk_signal_connect (GTK_WIDGET (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (set_location_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_check_button_new_with_label ("Allow shrink");
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
+ gtk_signal_connect (GTK_WIDGET (button),
+ "toggled",
+ GTK_SIGNAL_FUNC (allow_shrink_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_check_button_new_with_label ("Allow grow");
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
+ gtk_signal_connect (GTK_WIDGET (button),
+ "toggled",
+ GTK_SIGNAL_FUNC (allow_grow_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_check_button_new_with_label ("Auto shrink");
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
+ gtk_signal_connect (GTK_WIDGET (button),
+ "toggled",
+ GTK_SIGNAL_FUNC (auto_shrink_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ menu = gtk_menu_new ();
+
+ i = 0;
+ while (i < 10)
+ {
+ GtkWidget *mi;
+ static gchar *names[10] = {
+ "GDK_GRAVITY_NORTH_WEST",
+ "GDK_GRAVITY_NORTH",
+ "GDK_GRAVITY_NORTH_EAST",
+ "GDK_GRAVITY_WEST",
+ "GDK_GRAVITY_CENTER",
+ "GDK_GRAVITY_EAST",
+ "GDK_GRAVITY_SOUTH_WEST",
+ "GDK_GRAVITY_SOUTH",
+ "GDK_GRAVITY_SOUTH_EAST",
+ "GDK_GRAVITY_STATIC",
+ NULL
+ };
+
+ g_assert (names[i]);
+
+ mi = gtk_menu_item_new_with_label (names[i]);
+
+ gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+
+ ++i;
+ }
+
+ gtk_widget_show_all (menu);
+
+ om = gtk_option_menu_new ();
+ gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu);
+
+
+ gtk_signal_connect (GTK_OBJECT (om),
+ "changed",
+ GTK_SIGNAL_FUNC (gravity_selected),
+ control_window);
+
+ gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
+
+ gtk_widget_show_all (vbox);
+
+ return control_window;
+}
+
+void
+create_window_sizing (void)
+{
+ static GtkWidget *window = NULL;
+
+ if (!window)
+ {
+ GtkWidget *label;
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ label = gtk_label_new (NULL);
+ gtk_label_set_markup (GTK_LABEL (label), "<span foreground=\"purple\"><big>Window being resized</big></span>\nBlah blah blah blah\nblah blah blah\nblah blah blah blah blah");
+ gtk_container_add (GTK_CONTAINER (window), label);
+ gtk_widget_show (label);
+
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroyed),
+ &window);
+
+ gtk_window_set_title (GTK_WINDOW (window), "Window to size");
+
+ gtk_widget_show (window_controls (window));
+ }
+
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show (window);
+ else
+ gtk_widget_destroy (window);
+}
+
/*
* GtkProgressBar
*/
{ "tooltips", create_tooltips },
{ "tree", create_tree_mode_window},
{ "WM hints", create_wmhints },
+ { "window sizing", create_window_sizing },
{ "window states", create_window_states }
};
int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
gtk_widget_destroy (window);
}
+/*
+ * Window sizing
+ */
+
+static gint
+configure_event_callback (GtkWidget *widget,
+ GdkEventConfigure *event,
+ gpointer data)
+{
+ GtkWidget *label = data;
+ gchar *msg;
+ gint x, y;
+
+ gtk_window_get_location (GTK_WINDOW (widget), &x, &y);
+
+ msg = g_strdup_printf ("event: %d,%d %d x %d\n"
+ "location: %d, %d",
+ event->x, event->y, event->width, event->height,
+ x, y);
+
+ gtk_label_set_text (GTK_LABEL (label), msg);
+
+ g_free (msg);
+
+ return FALSE;
+}
+
+static void
+get_ints (GtkWidget *window,
+ gint *a,
+ gint *b)
+{
+ GtkWidget *spin1;
+ GtkWidget *spin2;
+
+ spin1 = g_object_get_data (G_OBJECT (window), "spin1");
+ spin2 = g_object_get_data (G_OBJECT (window), "spin2");
+
+ *a = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin1));
+ *b = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin2));
+}
+
+static void
+set_size_callback (GtkWidget *widget,
+ gpointer data)
+{
+ gint w, h;
+
+ get_ints (data, &w, &h);
+
+ gtk_window_set_size (g_object_get_data (data, "target"),
+ w, h);
+}
+
+static void
+set_default_size_callback (GtkWidget *widget,
+ gpointer data)
+{
+ gint w, h;
+
+ get_ints (data, &w, &h);
+
+ gtk_window_set_default_size (g_object_get_data (data, "target"),
+ w, h);
+}
+
+static void
+set_usize_callback (GtkWidget *widget,
+ gpointer data)
+{
+ gint w, h;
+
+ get_ints (data, &w, &h);
+
+ gtk_widget_set_usize (g_object_get_data (data, "target"),
+ w, h);
+}
+
+static void
+set_location_callback (GtkWidget *widget,
+ gpointer data)
+{
+ gint x, y;
+
+ get_ints (data, &x, &y);
+
+ gtk_window_set_location (g_object_get_data (data, "target"),
+ x, y);
+}
+
+static void
+allow_shrink_callback (GtkWidget *widget,
+ gpointer data)
+{
+ g_object_set (G_OBJECT (g_object_get_data (data, "target")),
+ "allow_shrink",
+ GTK_TOGGLE_BUTTON (widget)->active,
+ NULL);
+}
+
+static void
+allow_grow_callback (GtkWidget *widget,
+ gpointer data)
+{
+ g_object_set (G_OBJECT (g_object_get_data (data, "target")),
+ "allow_grow",
+ GTK_TOGGLE_BUTTON (widget)->active,
+ NULL);
+}
+
+static void
+auto_shrink_callback (GtkWidget *widget,
+ gpointer data)
+{
+ g_object_set (G_OBJECT (g_object_get_data (data, "target")),
+ "auto_shrink",
+ GTK_TOGGLE_BUTTON (widget)->active,
+ NULL);
+}
+
+static void
+gravity_selected (GtkWidget *widget,
+ gpointer data)
+{
+ gtk_window_set_gravity (G_OBJECT (g_object_get_data (data, "target")),
+ gtk_option_menu_get_history (GTK_OPTION_MENU (widget)) + GDK_GRAVITY_NORTH_WEST);
+}
+
+static GtkWidget*
+window_controls (GtkWidget *window)
+{
+ GtkWidget *control_window;
+ GtkWidget *label;
+ GtkWidget *vbox;
+ GtkWidget *button;
+ GtkWidget *spin;
+ GtkAdjustment *adj;
+ GtkWidget *om;
+ GtkWidget *menu;
+ gint i;
+
+ control_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_window_set_title (GTK_WINDOW (control_window), "Size controls");
+
+ g_object_set_data (G_OBJECT (control_window),
+ "target",
+ window);
+
+ gtk_signal_connect_object (GTK_OBJECT (control_window),
+ "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ GTK_OBJECT (window));
+
+ vbox = gtk_vbox_new (FALSE, 5);
+
+ gtk_container_add (GTK_CONTAINER (control_window), vbox);
+
+ label = gtk_label_new ("<no configure events>");
+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+ gtk_signal_connect (GTK_OBJECT (window),
+ "configure_event",
+ GTK_SIGNAL_FUNC (configure_event_callback),
+ label);
+
+ adj = (GtkAdjustment *) gtk_adjustment_new (10.0, -3.0, 800.0, 1.0,
+ 5.0, 0.0);
+ spin = gtk_spin_button_new (adj, 0, 0);
+
+ gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
+
+ g_object_set_data (G_OBJECT (control_window), "spin1", spin);
+
+ adj = (GtkAdjustment *) gtk_adjustment_new (10.0, -3.0, 800.0, 1.0,
+ 5.0, 0.0);
+ spin = gtk_spin_button_new (adj, 0, 0);
+
+ gtk_box_pack_start (GTK_BOX (vbox), spin, FALSE, FALSE, 0);
+
+ g_object_set_data (G_OBJECT (control_window), "spin2", spin);
+
+ button = gtk_button_new_with_label ("Queue resize");
+ gtk_signal_connect_object (GTK_WIDGET (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (gtk_widget_queue_resize),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Set size");
+ gtk_signal_connect (GTK_WIDGET (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (set_size_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Set default size");
+ gtk_signal_connect (GTK_WIDGET (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (set_default_size_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Set usize");
+ gtk_signal_connect (GTK_WIDGET (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (set_usize_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_button_new_with_label ("Set location");
+ gtk_signal_connect (GTK_WIDGET (button),
+ "clicked",
+ GTK_SIGNAL_FUNC (set_location_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_check_button_new_with_label ("Allow shrink");
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
+ gtk_signal_connect (GTK_WIDGET (button),
+ "toggled",
+ GTK_SIGNAL_FUNC (allow_shrink_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_check_button_new_with_label ("Allow grow");
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
+ gtk_signal_connect (GTK_WIDGET (button),
+ "toggled",
+ GTK_SIGNAL_FUNC (allow_grow_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ button = gtk_check_button_new_with_label ("Auto shrink");
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
+ gtk_signal_connect (GTK_WIDGET (button),
+ "toggled",
+ GTK_SIGNAL_FUNC (auto_shrink_callback),
+ GTK_OBJECT (control_window));
+ gtk_box_pack_end (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+
+ menu = gtk_menu_new ();
+
+ i = 0;
+ while (i < 10)
+ {
+ GtkWidget *mi;
+ static gchar *names[10] = {
+ "GDK_GRAVITY_NORTH_WEST",
+ "GDK_GRAVITY_NORTH",
+ "GDK_GRAVITY_NORTH_EAST",
+ "GDK_GRAVITY_WEST",
+ "GDK_GRAVITY_CENTER",
+ "GDK_GRAVITY_EAST",
+ "GDK_GRAVITY_SOUTH_WEST",
+ "GDK_GRAVITY_SOUTH",
+ "GDK_GRAVITY_SOUTH_EAST",
+ "GDK_GRAVITY_STATIC",
+ NULL
+ };
+
+ g_assert (names[i]);
+
+ mi = gtk_menu_item_new_with_label (names[i]);
+
+ gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+
+ ++i;
+ }
+
+ gtk_widget_show_all (menu);
+
+ om = gtk_option_menu_new ();
+ gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu);
+
+
+ gtk_signal_connect (GTK_OBJECT (om),
+ "changed",
+ GTK_SIGNAL_FUNC (gravity_selected),
+ control_window);
+
+ gtk_box_pack_end (GTK_BOX (vbox), om, FALSE, FALSE, 0);
+
+ gtk_widget_show_all (vbox);
+
+ return control_window;
+}
+
+void
+create_window_sizing (void)
+{
+ static GtkWidget *window = NULL;
+
+ if (!window)
+ {
+ GtkWidget *label;
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ label = gtk_label_new (NULL);
+ gtk_label_set_markup (GTK_LABEL (label), "<span foreground=\"purple\"><big>Window being resized</big></span>\nBlah blah blah blah\nblah blah blah\nblah blah blah blah blah");
+ gtk_container_add (GTK_CONTAINER (window), label);
+ gtk_widget_show (label);
+
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroyed),
+ &window);
+
+ gtk_window_set_title (GTK_WINDOW (window), "Window to size");
+
+ gtk_widget_show (window_controls (window));
+ }
+
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show (window);
+ else
+ gtk_widget_destroy (window);
+}
+
/*
* GtkProgressBar
*/
{ "tooltips", create_tooltips },
{ "tree", create_tree_mode_window},
{ "WM hints", create_wmhints },
+ { "window sizing", create_window_sizing },
{ "window states", create_window_states }
};
int nbuttons = sizeof (buttons) / sizeof (buttons[0]);
projects / gtk4.git / commitdiff